module klang.klang.节点访问.Klang节点访问_;
import 全局;
import ··klang类型_ = klang.klang.类型.klang类型_;
import ··核心_ = klang.编译.核心.核心_;
import ··类型_ = klang.编译.类型.类型_;
import ··节点_ = klang.编译.语法节点.节点_;
import klang.编译.核心.核心_: 整数_, 创建数组, 返回零值, 克隆数组;
import klang.编译.类型.枚举值.枚举值_: SK;
import klang.编译.语法节点.节点_: 基础节点_ = 节点_, 节点数组_;
import klang.klang.节点工厂.Klang工厂_: 节点工厂_ = Klang节点工厂_;
import klang.klang.类型.klang类型_: KSK;
import klang.编译.节点访问.访问节点_: Visitor, visitNode, visitNodes;
import klang.klang.语法节点.Klang节点_: 修饰符_, 表达式_, Klang节点_, Klang令牌_, klang文本字面量_, klang数字字面量_, klang小数字面量_, 类型节点_, 字符字面量_, 变量声明_, 变量声明列表_, 变量语句_, 标识符_ = Klang标识符_, 限定名_, 外部修饰符声明_, 标识符修饰符_, 导入成员基类_, 导入声明_, 导入从声明_, 导入从成员基类_, 导入成员_, 导入从成员_, 导入版本成员_, 导入成员块_, 导入从成员块_, 导入从版本成员_, 版本表达式语句_, 测试单元语句_, 语句_, 失踪声明_, 版本语句_, 块_, 指令语句_, 程序声明_, 正则表达式字面量_, 无替换模板字面量_, 模板头_, 模板中_, 模板尾_, 模板表达式_, 部分输出表达式_, 前缀一元表达式_, 后缀一元表达式_, 二元表达式_, 条件表达式_, 属性访问表达式_, 类型引用_, 静态二元表达式类型节点_, 类型形参_, 形参声明_, 签名声明_, 函数类型_, 区间类型节点_, 数组类型_, 元组类型节点_, 类型列表_, 联合类型_, 括号类型_, 词典类型_, 动态数组类型_, 指针类型_, 变长参数_, 类型限定类型_, 字面量类型_, 类型查询表达式_, 类型断言表达式_, 开放括号表达式_, 展开表达式_, 非空表达式_, 类型转换表达式_, 箭头函数_, 函数表达式_, 函数声明_, 构建声明_, 释放声明_, 接口声明_, 声明_, 继承子句_, 枚举成员_, 枚举声明_, 对象声明_, 结构声明_, 类型声明_, 属性声明_, 方法声明_, 别名声明_, 索引签名_, 运算符签名元素_, 运算符签名_, 数组字面量表达式_, 动态类字面量表达式_, 词典键值表达式_, 截取表达式_, 元素访问表达式_, 接口字面量表达式_, 结构字面量表达式_, 新建表达式_, 调用表达式_, 属性赋值_, 简洁属性赋值_, 表达式包含类型实参_, 符号引用表达式_, 空语句_, 如果语句_, 循环属于_, 循环语句_, 当循环语句_, 表达式列表表达式_, 跳出语句_, 继续语句_, 延迟语句_, 删除语句_, 返回语句_, 假如语句_, 若是块_, 若是或默认子句_, 若是子句_, 默认子句_, 抛出语句_, 断言语句_, 同步语句_, 尝试语句_, 捕获子句_, 标签语句_, 表达式语句_, Klang源文件_, 调试语句_;
T visitEachChild(T)(T n = ··null!(T), Visitor visitor = ··null!(Visitor), 节点工厂_ factory = ··null!(节点工厂_)) {
    if (n is ··null!(T)) {
        return n;
    }
    long kind = n.目标种类;
    // No need to visit nodes with no children.
    if ((kind > KSK.未知__ && kind <= KSK.类型_) && kind != KSK.标识符) {
        return n;
    }
    switch (kind) {
        case KSK.标识符: {
            标识符_ xn = (cast(标识符_)(n));
            return factory.更新标识符(xn, xn.标识符.内容, visitNodes!(Klang节点_)(xn.类型实参组, cast(Visitor)(visitor)));
        }
        case KSK.限定名: {
            限定名_ xn = (cast(限定名_)(n));
            return factory.更新限定名(xn, visitNode!(限定名_)(xn.左侧, cast(Visitor)(visitor)), visitNode!(标识符_)(xn.右侧, cast(Visitor)(visitor)));
        }
        case KSK.导入声明: {
            导入声明_ xn = (cast(导入声明_)(n));
            return factory.更新导入声明(xn, visitNodes!(导入成员基类_)(xn.导入组, cast(Visitor)(visitor)));
        }
        case KSK.导入从声明: {
            导入从声明_ xn = (cast(导入从声明_)(n));
            return factory.更新导入从声明(xn, visitNode!(··节点_.文本字面量_)(xn.模块名, cast(Visitor)(visitor)), visitNodes!(导入从成员基类_)(xn.导入组, cast(Visitor)(visitor)));
        }
        case KSK.导入成员: {
            导入成员_ xn = (cast(导入成员_)(n));
            return factory.更新导入成员(xn, visitNode!(··节点_.文本字面量_)(xn.模块名, cast(Visitor)(visitor)), visitNode!(标识符_)(xn.另命名名称, cast(Visitor)(visitor)), xn.包名, xn.符号名, xn.是公开的);
        }
        case KSK.导入从成员: {
            导入从成员_ xn = (cast(导入从成员_)(n));
            return factory.更新导入从成员(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNode!(标识符_)(xn.另命名名称, cast(Visitor)(visitor)));
        }
        case KSK.导入版本成员: {
            导入版本成员_ xn = (cast(导入版本成员_)(n));
            return factory.更新导入版本成员(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNode!(导入成员块_)(xn.然后语句, cast(Visitor)(visitor)), visitNode!(导入成员基类_)(xn.否则语句, cast(Visitor)(visitor)), xn.是顶级的);
        }
        case KSK.导入成员块: {
            导入成员块_ xn = (cast(导入成员块_)(n));
            return factory.更新导入成员块(xn, visitNodes!(导入成员基类_)(xn.语句组, cast(Visitor)(visitor)), xn.版本容器块种类, xn.多行, xn.是有效的, xn.版本语句路径);
        }
        case KSK.导入从成员块: {
            导入从成员块_ xn = (cast(导入从成员块_)(n));
            return factory.更新导入从成员块(xn, visitNodes!(导入从成员基类_)(xn.语句组, cast(Visitor)(visitor)), xn.版本容器块种类, xn.多行, xn.是有效的, xn.版本语句路径);
        }
        case KSK.导入从版本成员: {
            导入从版本成员_ xn = (cast(导入从版本成员_)(n));
            return factory.更新导入从版本成员(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNode!(导入从成员块_)(xn.然后语句, cast(Visitor)(visitor)), visitNode!(导入从成员基类_)(xn.否则语句, cast(Visitor)(visitor)), xn.是顶级的);
        }
        case KSK.版本表达式语句: {
            版本表达式语句_ xn = (cast(版本表达式语句_)(n));
            return factory.更新版本表达式语句(xn, visitNode!(标识符_)(xn.表达式, cast(Visitor)(visitor)));
        }
        case KSK.测试单元语句: {
            测试单元语句_ xn = (cast(测试单元语句_)(n));
            return factory.更新测试单元语句(xn, visitNodes!(Klang节点_)(xn.语句组, cast(Visitor)(visitor)), xn.版本容器块种类);
        }
        case KSK.版本语句: {
            版本语句_ xn = (cast(版本语句_)(n));
            return factory.更新版本语句(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNode!(块_)(xn.然后语句, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.否则语句, cast(Visitor)(visitor)), xn.是顶级的);
        }
        case KSK.块: {
            块_ xn = (cast(块_)(n));
            return factory.更新块(xn, visitNodes!(Klang节点_)(xn.语句组, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)), xn.版本容器块种类, xn.多行);
        }
        case KSK.指令语句: {
            指令语句_ xn = (cast(指令语句_)(n));
            return factory.更新指令语句(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNode!(··节点_.文本字面量_)(xn.参数, cast(Visitor)(visitor)));
        }
        case KSK.程序声明: {
            程序声明_ xn = (cast(程序声明_)(n));
            return factory.更新程序声明(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNodes!(Klang节点_)(xn.语句组, cast(Visitor)(visitor)), xn.结尾令牌, xn.是启动声明);
        }
        case KSK.模板表达式: {
            模板表达式_ xn = (cast(模板表达式_)(n));
            return factory.更新模板表达式(xn, visitNode!(模板头_)(xn.模板头, cast(Visitor)(visitor)), visitNodes!(模板中_)(xn.模板跨度, cast(Visitor)(visitor)), visitNode!(模板尾_)(xn.模板尾, cast(Visitor)(visitor)));
        }
        case KSK.部分输出表达式: {
            部分输出表达式_ xn = (cast(部分输出表达式_)(n));
            return factory.更新部分输出表达式(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)));
        }
        case KSK.前缀一元表达式: {
            前缀一元表达式_ xn = (cast(前缀一元表达式_)(n));
            return factory.更新前缀一元表达式(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), xn.运算符);
        }
        case KSK.后缀一元表达式: {
            后缀一元表达式_ xn = (cast(后缀一元表达式_)(n));
            return factory.更新后缀一元表达式(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), xn.运算符);
        }
        case KSK.二元表达式: {
            二元表达式_ xn = (cast(二元表达式_)(n));
            return factory.更新二元表达式(xn, visitNode!(Klang节点_)(xn.左侧, cast(Visitor)(visitor)), xn.运算符, visitNode!(Klang节点_)(xn.右侧, cast(Visitor)(visitor)));
        }
        case KSK.条件表达式: {
            条件表达式_ xn = (cast(条件表达式_)(n));
            return factory.更新条件表达式(xn, visitNode!(Klang节点_)(xn.条件, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.当真, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.当假, cast(Visitor)(visitor)));
        }
        case KSK.属性访问表达式: {
            属性访问表达式_ xn = (cast(属性访问表达式_)(n));
            return factory.更新属性访问表达式(xn, visitNode!(Klang节点_)(xn.左侧, cast(Visitor)(visitor)), visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)));
        }
        case KSK.类型引用: {
            类型引用_ xn = (cast(类型引用_)(n));
            return factory.更新类型引用(xn, visitNode!(限定名_)(xn.类型名称, cast(Visitor)(visitor)), visitNodes!(Klang节点_)(xn.类型实参组, cast(Visitor)(visitor)));
        }
        case KSK.静态二元表达式类型节点: {
            静态二元表达式类型节点_ xn = (cast(静态二元表达式类型节点_)(n));
            return factory.更新静态二元表达式类型节点(xn, visitNode!(Klang节点_)(xn.左侧, cast(Visitor)(visitor)), xn.运算符, visitNode!(Klang节点_)(xn.左侧, cast(Visitor)(visitor)));
        }
        case KSK.类型形参: {
            类型形参_ xn = (cast(类型形参_)(n));
            return factory.更新类型形参(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.约束, cast(Visitor)(visitor)));
        }
        case KSK.形参声明: {
            形参声明_ xn = (cast(形参声明_)(n));
            return factory.更新形参声明(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)), xn.问号, visitNode!(Klang节点_)(xn.初始化, cast(Visitor)(visitor)));
        }
        case KSK.函数类型: {
            函数类型_ xn = (cast(函数类型_)(n));
            return factory.更新函数类型(xn, visitNodes!(形参声明_)(xn.形参组, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNodes!(类型形参_)(xn.类型形参, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.区间类型节点: {
            区间类型节点_ xn = (cast(区间类型节点_)(n));
            return factory.更新区间类型节点(xn, visitNode!(Klang节点_)(xn.区间开始, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.区间结束, cast(Visitor)(visitor)));
        }
        case KSK.数组类型: {
            数组类型_ xn = (cast(数组类型_)(n));
            return factory.更新数组类型(xn, visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.长度, cast(Visitor)(visitor)));
        }
        case KSK.元组类型节点: {
            元组类型节点_ xn = (cast(元组类型节点_)(n));
            return factory.更新元组类型节点(xn, visitNodes!(Klang节点_)(xn.类型组, cast(Visitor)(visitor)));
        }
        case KSK.类型列表: {
            类型列表_ xn = (cast(类型列表_)(n));
            return factory.更新类型列表(xn, visitNodes!(Klang节点_)(xn.类型组, cast(Visitor)(visitor)));
        }
        case KSK.联合类型: {
            联合类型_ xn = (cast(联合类型_)(n));
            return factory.更新联合类型(xn, visitNodes!(Klang节点_)(xn.类型组, cast(Visitor)(visitor)));
        }
        case KSK.括号类型: {
            括号类型_ xn = (cast(括号类型_)(n));
            return factory.更新括号类型(xn, visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)));
        }
        case KSK.词典类型: {
            词典类型_ xn = (cast(词典类型_)(n));
            return factory.更新词典类型(xn, visitNode!(Klang节点_)(xn.值类型, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.键类型, cast(Visitor)(visitor)));
        }
        case KSK.动态数组类型: {
            动态数组类型_ xn = (cast(动态数组类型_)(n));
            return factory.更新动态数组类型(xn, visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)));
        }
        case KSK.指针类型: {
            指针类型_ xn = (cast(指针类型_)(n));
            return factory.更新指针类型(xn, visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)));
        }
        case KSK.变长参数: {
            变长参数_ xn = (cast(变长参数_)(n));
            return factory.更新变长参数(xn, visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)));
        }
        case KSK.类型限定类型: {
            类型限定类型_ xn = (cast(类型限定类型_)(n));
            return factory.更新类型限定类型(xn, xn.限定符, visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)));
        }
        case KSK.字面量类型: {
            字面量类型_ xn = (cast(字面量类型_)(n));
            return factory.更新字面量类型(xn, visitNode!(Klang节点_)(xn.字面量, cast(Visitor)(visitor)));
        }
        case KSK.类型查询表达式: {
            类型查询表达式_ xn = (cast(类型查询表达式_)(n));
            return factory.更新类型查询表达式(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)));
        }
        case KSK.类型断言表达式: {
            类型断言表达式_ xn = (cast(类型断言表达式_)(n));
            return factory.更新类型断言表达式(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)));
        }
        case KSK.展开表达式: {
            展开表达式_ xn = (cast(展开表达式_)(n));
            return factory.更新展开表达式(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)));
        }
        case KSK.非空表达式: {
            非空表达式_ xn = (cast(非空表达式_)(n));
            return factory.更新非空表达式(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)));
        }
        case KSK.类型转换表达式: {
            类型转换表达式_ xn = (cast(类型转换表达式_)(n));
            return factory.更新类型转换表达式(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)));
        }
        case KSK.箭头函数: {
            箭头函数_ xn = (cast(箭头函数_)(n));
            return factory.更新箭头函数(xn, visitNodes!(类型形参_)(xn.类型形参, cast(Visitor)(visitor)), visitNodes!(形参声明_)(xn.形参组, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNode!(基础节点_)(xn.函数体, cast(Visitor)(visitor)));
        }
        case KSK.函数表达式: {
            函数表达式_ xn = (cast(函数表达式_)(n));
            return factory.更新函数表达式(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNodes!(类型形参_)(xn.类型形参, cast(Visitor)(visitor)), visitNodes!(形参声明_)(xn.形参组, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNode!(基础节点_)(xn.函数体, cast(Visitor)(visitor)));
        }
        case KSK.函数声明: {
            函数声明_ xn = (cast(函数声明_)(n));
            return factory.更新函数声明(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNodes!(类型形参_)(xn.类型形参, cast(Visitor)(visitor)), visitNodes!(形参声明_)(xn.形参组, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNode!(基础节点_)(xn.函数体, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.构建声明: {
            构建声明_ xn = (cast(构建声明_)(n));
            return factory.更新构建声明(xn, visitNodes!(形参声明_)(xn.形参组, cast(Visitor)(visitor)), visitNode!(基础节点_)(xn.函数体, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.释放声明: {
            释放声明_ xn = (cast(释放声明_)(n));
            return factory.更新释放声明(xn, visitNode!(基础节点_)(xn.函数体, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.接口声明: {
            接口声明_ xn = (cast(接口声明_)(n));
            return factory.更新接口声明(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNodes!(类型形参_)(xn.类型形参, cast(Visitor)(visitor)), visitNodes!(Klang节点_)(xn.成员组, cast(Visitor)(visitor)), visitNodes!(继承子句_)(xn.继承子句, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.枚举声明: {
            枚举声明_ xn = (cast(枚举声明_)(n));
            return factory.更新枚举声明(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNodes!(枚举成员_)(xn.成员组, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.枚举成员: {
            枚举成员_ xn = (cast(枚举成员_)(n));
            return factory.更新枚举成员(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.初始化, cast(Visitor)(visitor)));
        }
        case KSK.对象声明: {
            对象声明_ xn = (cast(对象声明_)(n));
            return factory.更新对象声明(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNodes!(Klang节点_)(xn.成员组, cast(Visitor)(visitor)), visitNodes!(类型形参_)(xn.类型形参, cast(Visitor)(visitor)), visitNodes!(继承子句_)(xn.继承子句, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.结构声明: {
            结构声明_ xn = (cast(结构声明_)(n));
            return factory.更新结构声明(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNodes!(Klang节点_)(xn.成员组, cast(Visitor)(visitor)), visitNodes!(类型形参_)(xn.类型形参, cast(Visitor)(visitor)), visitNodes!(继承子句_)(xn.继承子句, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.类型声明: {
            类型声明_ xn = (cast(类型声明_)(n));
            return factory.更新类型声明(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNodes!(Klang节点_)(xn.成员组, cast(Visitor)(visitor)), visitNodes!(类型形参_)(xn.类型形参, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.属性声明: {
            属性声明_ xn = (cast(属性声明_)(n));
            return factory.更新属性声明(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.初始化, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)), xn.问号);
        }
        case KSK.方法声明: {
            方法声明_ xn = (cast(方法声明_)(n));
            return factory.更新方法声明(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNodes!(类型形参_)(xn.类型形参, cast(Visitor)(visitor)), visitNodes!(形参声明_)(xn.形参组, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNode!(基础节点_)(xn.函数体, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.别名声明: {
            别名声明_ xn = (cast(别名声明_)(n));
            return factory.更新别名声明(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNodes!(类型形参_)(xn.类型形参, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.索引签名: {
            索引签名_ xn = (cast(索引签名_)(n));
            return factory.更新索引签名(xn, visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNode!(形参声明_)(xn.形参, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.运算符签名: {
            运算符签名_ xn = (cast(运算符签名_)(n));
            return factory.更新运算符签名(xn, visitNodes!(运算符签名元素_)(xn.运算符组, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.运算符签名元素: {
            运算符签名元素_ xn = (cast(运算符签名元素_)(n));
            return factory.更新运算符签名元素(xn, xn.运算符, visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)));
        }
        case KSK.数组字面量表达式: {
            数组字面量表达式_ xn = (cast(数组字面量表达式_)(n));
            return factory.更新数组字面量表达式(xn, visitNodes!(Klang节点_)(xn.元素组, cast(Visitor)(visitor)), xn.多行);
        }
        case KSK.动态类字面量表达式: {
            动态类字面量表达式_ xn = (cast(动态类字面量表达式_)(n));
            return factory.更新动态类字面量表达式(xn, visitNodes!(Klang节点_)(xn.元素组, cast(Visitor)(visitor)), xn.多行);
        }
        case KSK.词典键值表达式: {
            词典键值表达式_ xn = (cast(词典键值表达式_)(n));
            return factory.更新词典键值表达式(xn, visitNode!(Klang节点_)(xn.键表达式, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.值表达式, cast(Visitor)(visitor)));
        }
        case KSK.截取表达式: {
            截取表达式_ xn = (cast(截取表达式_)(n));
            return factory.更新截取表达式(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.截取开始, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.截取结尾, cast(Visitor)(visitor)));
        }
        case KSK.元素访问表达式: {
            元素访问表达式_ xn = (cast(元素访问表达式_)(n));
            return factory.更新元素访问表达式(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.参数表达式, cast(Visitor)(visitor)));
        }
        case KSK.接口字面量表达式: {
            接口字面量表达式_ xn = (cast(接口字面量表达式_)(n));
            return factory.更新接口字面量表达式(xn, visitNodes!(Klang节点_)(xn.属性组, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), xn.多行);
        }
        case KSK.结构字面量表达式: {
            结构字面量表达式_ xn = (cast(结构字面量表达式_)(n));
            return factory.更新结构字面量表达式(xn, visitNodes!(Klang节点_)(xn.属性组, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型注释节点, cast(Visitor)(visitor)), xn.多行);
        }
        case KSK.新建表达式: {
            新建表达式_ xn = (cast(新建表达式_)(n));
            return factory.更新新建表达式(xn, visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNodes!(Klang节点_)(xn.实参组, cast(Visitor)(visitor)));
        }
        case KSK.调用表达式: {
            调用表达式_ xn = (cast(调用表达式_)(n));
            return factory.更新调用表达式(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNodes!(Klang节点_)(xn.实参组, cast(Visitor)(visitor)), visitNodes!(Klang节点_)(xn.类型实参组, cast(Visitor)(visitor)));
        }
        case KSK.属性赋值: {
            属性赋值_ xn = (cast(属性赋值_)(n));
            return factory.更新属性赋值(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.初始化, cast(Visitor)(visitor)));
        }
        case KSK.简洁属性赋值: {
            简洁属性赋值_ xn = (cast(简洁属性赋值_)(n));
            return factory.更新简洁属性赋值(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.初始化, cast(Visitor)(visitor)));
        }
        case KSK.表达式包含类型实参: {
            表达式包含类型实参_ xn = (cast(表达式包含类型实参_)(n));
            return factory.更新表达式包含类型实参(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNodes!(Klang节点_)(xn.类型实参组, cast(Visitor)(visitor)));
        }
        case KSK.继承子句: {
            继承子句_ xn = (cast(继承子句_)(n));
            return factory.更新继承子句(xn, visitNodes!(表达式包含类型实参_)(xn.类型组, cast(Visitor)(visitor)));
        }
        case KSK.符号引用表达式: {
            符号引用表达式_ xn = (cast(符号引用表达式_)(n));
            return factory.更新符号引用表达式(xn, visitNode!(标识符_)(xn.表达式, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.变量声明: {
            变量声明_ xn = (cast(变量声明_)(n));
            return factory.更新变量声明(xn, visitNode!(标识符_)(xn.名称, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.类型, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.初始化, cast(Visitor)(visitor)), visitNode!(Klang令牌_!(KSK))(xn.叹号令牌, cast(Visitor)(visitor)));
        }
        case KSK.变量语句: {
            变量语句_ xn = (cast(变量语句_)(n));
            return factory.更新变量声明语句(xn, visitNode!(变量声明列表_)(xn.声明列表, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.变量声明列表: {
            变量声明列表_ xn = (cast(变量声明列表_)(n));
            return factory.更新变量声明列表(xn, visitNodes!(变量声明_)(xn.声明组, cast(Visitor)(visitor)), visitNodes!(修饰符_)(xn.修饰符, cast(Visitor)(visitor)));
        }
        case KSK.如果语句: {
            如果语句_ xn = (cast(如果语句_)(n));
            return factory.更新如果语句(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.然后语句, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.否则语句, cast(Visitor)(visitor)));
        }
        case KSK.循环语句: {
            循环语句_ xn = (cast(循环语句_)(n));
            return factory.更新循环语句(xn, visitNode!(Klang节点_)(xn.初始化, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.条件, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.自增, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.语句, cast(Visitor)(visitor)));
        }
        case KSK.当循环语句: {
            当循环语句_ xn = (cast(当循环语句_)(n));
            return factory.更新当循环语句(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.语句, cast(Visitor)(visitor)));
        }
        case KSK.表达式列表表达式: {
            表达式列表表达式_ xn = (cast(表达式列表表达式_)(n));
            return factory.更新表达式列表表达式(xn, visitNodes!(Klang节点_)(xn.元素组, cast(Visitor)(visitor)));
        }
        case KSK.跳出语句: {
            跳出语句_ xn = (cast(跳出语句_)(n));
            return factory.更新跳出语句(xn, visitNode!(标识符_)(xn.标签, cast(Visitor)(visitor)));
        }
        case KSK.继续语句: {
            继续语句_ xn = (cast(继续语句_)(n));
            return factory.更新继续语句(xn, visitNode!(标识符_)(xn.标签, cast(Visitor)(visitor)));
        }
        case KSK.延迟语句: {
            延迟语句_ xn = (cast(延迟语句_)(n));
            return factory.更新延迟语句(xn, visitNode!(Klang节点_)(xn.语句, cast(Visitor)(visitor)));
        }
        case KSK.删除语句: {
            删除语句_ xn = (cast(删除语句_)(n));
            return factory.更新删除语句(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)));
        }
        case KSK.返回语句: {
            返回语句_ xn = (cast(返回语句_)(n));
            return factory.更新返回语句(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)));
        }
        case KSK.假如语句: {
            假如语句_ xn = (cast(假如语句_)(n));
            return factory.更新假如语句(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNode!(若是块_)(xn.若是块, cast(Visitor)(visitor)), xn.possiblyExhaustive);
        }
        case KSK.若是子句: {
            若是子句_ xn = (cast(若是子句_)(n));
            return factory.更新若是子句(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)), visitNodes!(Klang节点_)(xn.语句组, cast(Visitor)(visitor)), xn.fallthroughFlowNode);
        }
        case KSK.默认子句: {
            默认子句_ xn = (cast(默认子句_)(n));
            return factory.更新默认子句(xn, visitNodes!(Klang节点_)(xn.语句组, cast(Visitor)(visitor)), xn.fallthroughFlowNode);
        }
        case KSK.若是块: {
            若是块_ xn = (cast(若是块_)(n));
            return factory.更新若是块(xn, visitNodes!(若是或默认子句_)(xn.子句组, cast(Visitor)(visitor)));
        }
        case KSK.抛出语句: {
            抛出语句_ xn = (cast(抛出语句_)(n));
            return factory.更新抛出语句(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)));
        }
        case KSK.断言语句: {
            断言语句_ xn = (cast(断言语句_)(n));
            return factory.更新断言语句(xn, visitNodes!(Klang节点_)(xn.实参组, cast(Visitor)(visitor)));
        }
        case KSK.同步语句: {
            同步语句_ xn = (cast(同步语句_)(n));
            return factory.更新同步语句(xn, visitNodes!(Klang节点_)(xn.实参组, cast(Visitor)(visitor)), visitNodes!(Klang节点_)(xn.语句组, cast(Visitor)(visitor)));
        }
        case KSK.尝试语句: {
            尝试语句_ xn = (cast(尝试语句_)(n));
            return factory.更新尝试语句(xn, visitNode!(块_)(xn.尝试块, cast(Visitor)(visitor)), visitNode!(捕获子句_)(xn.捕获子句, cast(Visitor)(visitor)), visitNode!(块_)(xn.最后块, cast(Visitor)(visitor)));
        }
        case KSK.捕获子句: {
            捕获子句_ xn = (cast(捕获子句_)(n));
            return factory.更新捕获子句(xn, visitNode!(Klang节点_)(xn.变量声明, cast(Visitor)(visitor)), visitNode!(块_)(xn.块, cast(Visitor)(visitor)));
        }
        case KSK.标签语句: {
            标签语句_ xn = (cast(标签语句_)(n));
            return factory.更新标签语句(xn, visitNode!(标识符_)(xn.标签, cast(Visitor)(visitor)), visitNode!(Klang节点_)(xn.语句, cast(Visitor)(visitor)));
        }
        case KSK.表达式语句: {
            表达式语句_ xn = (cast(表达式语句_)(n));
            return factory.更新表达式语句(xn, visitNode!(Klang节点_)(xn.表达式, cast(Visitor)(visitor)));
        }
        case KSK.外部修饰符声明: {
            外部修饰符声明_ xn = (cast(外部修饰符声明_)(n));
            return factory.更新外部修饰符声明(xn, visitNode!(修饰符_)(xn.修饰符节点, cast(Visitor)(visitor)), visitNode!(限定名_)(xn.名称空间, cast(Visitor)(visitor)));
        }
        case KSK.标识符修饰符: {
            标识符修饰符_ xn = (cast(标识符修饰符_)(n));
            return factory.更新标识符修饰符(xn, visitNode!(标识符_)(xn.标识符, cast(Visitor)(visitor)));
        }
        default: break;
    }
    return n;
}
